/**
 * 根据样本量,和随机数种子,生成一个随机数,可复现
 * @param length  样本最大值,如60000
 * @param count  抽取个数
 * @param seed  随机种子
 * @returns 
 */
export function getReproducibleRandomValues(length: number, count: number, seed: number): number[] {
    // 生成一个基于种子的伪随机数生成器
    function createPseudoRandom(seed: number) {
        return () => {
            let x = Math.sin(seed++) * 10000;
            return x - Math.floor(x);
        };
    }

    const pseudoRandom = createPseudoRandom(seed);

    // 生成 1 到 length 的数组
    const array = Array.from({ length }, (_, i) => i + 1);

    // 复制数组以避免修改原始数组
    const copy = [...array];

    // 随机打乱数组
    for (let i = copy.length - 1; i > 0; i--) {
        const j = Math.floor(pseudoRandom() * (i + 1));
        [copy[i], copy[j]] = [copy[j], copy[i]];
    }

    // 返回前 count 个元素
    let arr = copy.slice(0, count).sort((a, b) => a - b);
    return arr;
}
/**
 * 生成不可重现的随机数组 用洗牌法,
 * @param totalNumbers 
 * @param extractNumber 
 * @returns 
 */
export function getNotReproRandomValues(totalNumbers: number, extractNumber: number): number[] {

    const numbers = Array.from({ length: totalNumbers }, (_, i) => i + 1); // 生成1到totalNumbers的数组
    if (extractNumber > totalNumbers) {
        return numbers;
    }
    // Fisher-Yates 洗牌算法
    for (let i = totalNumbers - 1; i > totalNumbers - extractNumber - 1; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [numbers[i], numbers[j]] = [numbers[j], numbers[i]];
    }

    // 返回最后extractNumber个数
    return numbers.slice(totalNumbers - extractNumber).sort((a, b) => a - b);
}
